1 package net.sourceforge.simplegamenet.chess;
2
3 import java.awt.*;
4 import java.awt.event.MouseEvent;
5 import javax.swing.*;
6 import javax.swing.event.MouseInputListener;
7
8 public class ChessPlayFieldComponent extends JComponent
9 implements ChessPlayFieldState, ChessPieceType,
10 ChessPieceOwner, MouseInputListener {
11
12 public static final int IMAGE_PART_WIDTH = 50;
13 public static final int IMAGE_PART_HEIGHT = 50;
14
15 private ChessPanel chessPanel;
16
17 private Image piecesImage;
18 private Image squaresImage;
19
20 private ChessPlayerClient chessPlayerClient;
21
22 private int[][] pieceTypeGrid = ChessPlayField.DEFAULT_PIECE_TYPE_GRID;
23 private int[][] pieceOwnerGrid = ChessPlayField.DEFAULT_PIECE_OWNER_GRID;
24
25 private boolean[][] moveSourceAllowedGrid = null;
26 private boolean[][] moveDestinationAllowedGrid = null;
27
28 private int selectedX = -1;
29 private int selectedY = -1;
30 private int reviewedX = -1;
31 private int reviewedY = -1;
32
33 private int pieceOwnerSight = WHITE_OWNER;
34
35 public ChessPlayFieldComponent(ChessPlayerClient chessPlayerClient, ChessPanel chessPanel,
36 Image piecesImage, Image squaresImage) {
37 super();
38 this.chessPlayerClient = chessPlayerClient;
39 this.chessPanel = chessPanel;
40 this.piecesImage = piecesImage;
41 this.squaresImage = squaresImage;
42 setMinimumSize(new Dimension(IMAGE_PART_WIDTH * ChessPlayField.GRID_WIDTH,
43 IMAGE_PART_HEIGHT * ChessPlayField.GRID_HEIGHT));
44 setPreferredSize(new Dimension(IMAGE_PART_WIDTH * ChessPlayField.GRID_WIDTH,
45 IMAGE_PART_HEIGHT * ChessPlayField.GRID_HEIGHT));
46 addMouseListener(this);
47 addMouseMotionListener(this);
48 }
49
50 public void setPieceOwnerSight(int pieceOwnerSight) {
51 this.pieceOwnerSight = pieceOwnerSight;
52 }
53
54 public void setEnabled(boolean enabled) {
55 super.setEnabled(enabled);
56 if (enabled) {
57 moveSourceAllowedGrid = chessPlayerClient.getMoveSourceAllowedGrid();
58 } else {
59 selectedX = -1;
60 selectedY = -1;
61 reviewedX = -1;
62 reviewedY = -1;
63 repaint();
64 }
65 }
66
67 public void playFieldUpdated(int[][] pieceTypeGrid, int[][] pieceOwnerGrid) {
68 this.pieceTypeGrid = pieceTypeGrid;
69 this.pieceOwnerGrid = pieceOwnerGrid;
70 repaint();
71 }
72
73 public void paintComponent(Graphics graphics) {
74 super.paintComponent(graphics);
75 int y = 0;
76 int x = 0;
77 for (int i = 0; i < ChessPlayField.GRID_WIDTH; i++) {
78 for (int j = 0; j < ChessPlayField.GRID_HEIGHT; j++) {
79 switch (pieceOwnerSight) {
80 case WHITE_OWNER:
81 case NO_OWNER:
82 x = i * IMAGE_PART_WIDTH;
83 y = j * IMAGE_PART_HEIGHT;
84 break;
85 case BLACK_OWNER:
86 x = (ChessPlayField.GRID_WIDTH - i - 1) * IMAGE_PART_WIDTH;
87 y = (ChessPlayField.GRID_HEIGHT - j - 1) * IMAGE_PART_HEIGHT;
88 break;
89 }
90 graphics.drawImage(squaresImage, x, y,
91 x + IMAGE_PART_WIDTH, y + IMAGE_PART_HEIGHT,
92 ((i + j) % 2) * IMAGE_PART_WIDTH, 0,
93 ((i + j) % 2 + 1) * IMAGE_PART_WIDTH, IMAGE_PART_HEIGHT,
94 this);
95 if (pieceTypeGrid[i][j] == NO_TYPE) {
96 if (selectedX >= 0 && selectedY >= 0 && reviewedX == i && reviewedY == j) {
97 int pieceIndex = getPieceIndex(selectedX, selectedY);
98 graphics.drawImage(piecesImage, x, y,
99 x + IMAGE_PART_WIDTH, y + IMAGE_PART_HEIGHT,
100 pieceIndex * IMAGE_PART_WIDTH, 3 * IMAGE_PART_HEIGHT,
101 (pieceIndex + 1) * IMAGE_PART_WIDTH, 4 * IMAGE_PART_HEIGHT,
102 this);
103 }
104 } else {
105 int pieceIndex = getPieceIndex(i, j);
106 int pieceState = 0;
107 if (selectedX >= 0 && selectedY >= 0) {
108 if (selectedX == i && selectedY == j) {
109 pieceState = 2;
110 } else {
111 if (reviewedX == i && reviewedY == j) {
112 pieceState = 4;
113 } else {
114 pieceState = 0;
115 }
116 }
117 } else {
118 if (reviewedX == i && reviewedY == j) {
119 pieceState = 1;
120 } else {
121 pieceState = 0;
122 }
123 }
124 graphics.drawImage(piecesImage, x, y,
125 x + IMAGE_PART_WIDTH, y + IMAGE_PART_HEIGHT,
126 pieceIndex * IMAGE_PART_WIDTH,
127 pieceState * IMAGE_PART_HEIGHT,
128 (pieceIndex + 1) * IMAGE_PART_WIDTH,
129 (pieceState + 1) * IMAGE_PART_HEIGHT,
130 this);
131 }
132 }
133 }
134 }
135
136 private int getPieceIndex(int i, int j) {
137 int pieceIndex = pieceOwnerGrid[i][j] == BLACK_OWNER ? 6 : 0;
138 switch (pieceTypeGrid[i][j]) {
139 case KING:
140 return pieceIndex;
141 case QUEEN:
142 return pieceIndex + 1;
143 case BISHOP:
144 return pieceIndex + 2;
145 case KNIGHT:
146 return pieceIndex + 3;
147 case ROOK:
148 return pieceIndex + 4;
149 case PAWN:
150 return pieceIndex + 5;
151 }
152 return pieceIndex + 5;
153 }
154
155 /***
156 * Invoked when the mouse button has been clicked (pressed
157 * and released) on a component.
158 */
159 public void mouseClicked(MouseEvent mouseEvent) {
160 }
161
162 /***
163 * Invoked when a mouse button is pressed on a component and then
164 * dragged. <code>MOUSE_DRAGGED</code> events will continue to be
165 * delivered to the component where the drag originated until the
166 * mouse button is released (regardless of whether the mouse position
167 * is within the bounds of the component).
168 * <p/>
169 * Due to platform-dependent Drag&Drop implementations,
170 * <code>MOUSE_DRAGGED</code> events may not be delivered during a native
171 * Drag&Drop operation.
172 */
173 public void mouseDragged(MouseEvent mouseEvent) {
174 }
175
176 /***
177 * Invoked when the mouse enters a component.
178 */
179 public void mouseEntered(MouseEvent mouseEvent) {
180 }
181
182 /***
183 * Invoked when the mouse exits a component.
184 */
185 public void mouseExited(MouseEvent mouseEvent) {
186 reviewedX = -1;
187 reviewedY = -1;
188 repaint();
189 }
190
191 /***
192 * Invoked when the mouse cursor has been moved onto a component
193 * but no buttons have been pushed.
194 */
195 public void mouseMoved(MouseEvent mouseEvent) {
196 if (isEnabled()) {
197 int x = mouseEvent.getX() / IMAGE_PART_WIDTH;
198 int y = mouseEvent.getY() / IMAGE_PART_HEIGHT;
199 if (pieceOwnerSight == BLACK_OWNER) {
200 x = ChessPlayField.GRID_WIDTH - x - 1;
201 y = ChessPlayField.GRID_HEIGHT - y - 1;
202 }
203 if (selectedX >= 0 && selectedY >= 0) {
204 if (!moveDestinationAllowedGrid[x][y]) {
205 x = -1;
206 y = -1;
207 }
208 } else {
209 if (!moveSourceAllowedGrid[x][y]) {
210 x = -1;
211 y = -1;
212 }
213 }
214 if (reviewedX != x || reviewedY != y) {
215 reviewedX = x;
216 reviewedY = y;
217 repaint();
218 }
219 }
220 }
221
222 /***
223 * Invoked when a mouse button has been pressed on a component.
224 */
225 public void mousePressed(MouseEvent mouseEvent) {
226 if (isEnabled()) {
227 int x = mouseEvent.getX() / IMAGE_PART_WIDTH;
228 int y = mouseEvent.getY() / IMAGE_PART_HEIGHT;
229 if (pieceOwnerSight == BLACK_OWNER) {
230 x = ChessPlayField.GRID_WIDTH - x - 1;
231 y = ChessPlayField.GRID_HEIGHT - y - 1;
232 }
233 if (selectedY >= 0 && selectedX >= 0) {
234 if (moveDestinationAllowedGrid[x][y]) {
235 chessPanel.makeMove(selectedX, selectedY, x, y);
236 }
237 selectedX = -1;
238 selectedY = -1;
239 reviewedX = -1;
240 reviewedY = -1;
241 repaint();
242 } else {
243 if (moveSourceAllowedGrid[x][y]) {
244 moveDestinationAllowedGrid =
245 chessPlayerClient.getMoveDestinationAllowedGrid(x, y);
246 selectedX = x;
247 selectedY = y;
248 reviewedX = -1;
249 reviewedY = -1;
250 repaint();
251 }
252 }
253 }
254 }
255
256 /***
257 * Invoked when a mouse button has been released on a component.
258 */
259 public void mouseReleased(MouseEvent mouseEvent) {
260 }
261
262 }